juce/source/extras/the jucer/src/model/documents/jucer_ButtonDocument.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../../jucer_Headers.h"
  27 #include "jucer_ButtonDocument.h"
  28
  29 //==============================================================================
  30 static const int normalOff = 0;
  31 static const int overOff = 1;
  32 static const int downOff = 2;
  33 static const int normalOn = 3;
  34 static const int overOn = 4;
  35 static const int downOn = 5;
  36 static const int background = 6;
  37
  38
  39 //==============================================================================
  40 ButtonDocument::ButtonDocument()
  41 {
  42     paintStatesEnabled [normalOff] = true;
  43     paintStatesEnabled [overOff] = true;
  44     paintStatesEnabled [downOff] = true;
  45     paintStatesEnabled [normalOn] = false;
  46     paintStatesEnabled [overOn] = false;
  47     paintStatesEnabled [downOn] = false;
  48     paintStatesEnabled [background] = false;
  49
  50     parentClasses = "public Button";
  51
  52     for (int i = 7; --i >= 0;)
  53     {
  54         paintRoutines [i] = new PaintRoutine();
  55         paintRoutines [i]->setDocument (this);
  56         paintRoutines [i]->setBackgroundColour (Colours::transparentBlack);
  57     }
  58 }
  59
  60 ButtonDocument::~ButtonDocument()
  61 {
  62     for (int i = 7; --i >= 0;)
  63         delete paintRoutines [i];
  64 }
  65
  66 static const char* const stateNames[] =
  67 {
  68     "normal", "over", "down",
  69     "normal on", "over on", "down on",
  70     "common background"
  71 };
  72
  73 int stateNameToIndex (const String& name)
  74 {
  75     for (int i = 7; --i >= 0;)
  76         if (name.equalsIgnoreCase (stateNames[i]))
  77             return i;
  78
  79     jassertfalse
  80     return normalOff;
  81 }
  82
  83
  84 int ButtonDocument::getNumPaintRoutines() const
  85 {
  86     int n = 0;
  87
  88     for (int i = 7; --i >= 0;)
  89         if (paintStatesEnabled [i])
  90             ++n;
  91
  92     return n;
  93 }
  94
  95 const StringArray ButtonDocument::getPaintRoutineNames() const
  96 {
  97     StringArray s;
  98
  99     for (int i = 0; i < 7; ++i)
 100         if (paintStatesEnabled [i])
 101             s.add (stateNames [i]);
 102
 103     return s;
 104 }
 105
 106 PaintRoutine* ButtonDocument::getPaintRoutine (const int index) const
 107 {
 108     int n = 0;
 109
 110     for (int i = 0; i < 7; ++i)
 111     {
 112         if (paintStatesEnabled [i])
 113         {
 114             if (index == n)
 115                 return paintRoutines [i];
 116             else
 117                 ++n;
 118         }
 119     }
 120
 121     jassertfalse
 122     return 0;
 123 }
 124
 125 void ButtonDocument::setStatePaintRoutineEnabled (const int index, bool b)
 126 {
 127     jassert (index > 0 && index < 7);
 128
 129     if (paintStatesEnabled [index] != b)
 130     {
 131         paintStatesEnabled [index] = b;
 132         changed();
 133     }
 134 }
 135
 136 bool ButtonDocument::isStatePaintRoutineEnabled (const int index) const
 137 {
 138     return paintStatesEnabled [index];
 139 }
 140
 141 int ButtonDocument::chooseBestEnabledPaintRoutine (int paintRoutineWanted) const
 142 {
 143     switch (paintRoutineWanted)
 144     {
 145     case normalOff:
 146         return normalOff;
 147
 148     case overOff:
 149         return paintStatesEnabled [overOff] ? overOff : normalOff;
 150
 151     case downOff:
 152         return paintStatesEnabled [downOff] ? downOff : chooseBestEnabledPaintRoutine (overOff);
 153
 154     case normalOn:
 155         return paintStatesEnabled [normalOn] ? normalOn : normalOff;
 156
 157     case overOn:
 158         return paintStatesEnabled [overOn] ? overOn : (paintStatesEnabled [normalOn] ? normalOn : chooseBestEnabledPaintRoutine (overOff));
 159
 160     case downOn:
 161         return paintStatesEnabled [downOn] ? downOn
 162                                                : ((paintStatesEnabled [overOn] || paintStatesEnabled [normalOn])
 163                                                     ? chooseBestEnabledPaintRoutine (overOn)
 164                                                     : chooseBestEnabledPaintRoutine (downOff));
 165
 166     default:
 167         jassertfalse
 168         break;
 169     }
 170
 171     return normalOff;
 172 }
 173
 174 //==============================================================================
 175 const String ButtonDocument::getTypeName() const
 176 {
 177     return "Button";
 178 }
 179
 180 JucerDocument* ButtonDocument::createCopy()
 181 {
 182     ButtonDocument* newOne = new ButtonDocument();
 183
 184     newOne->resources = resources;
 185     newOne->setFile (getFile());
 186
 187     XmlElement* const xml = createXml();
 188     newOne->loadFromXml (*xml);
 189     delete xml;
 190
 191     return newOne;
 192 }
 193
 194 XmlElement* ButtonDocument::createXml() const
 195 {
 196     XmlElement* const doc = JucerDocument::createXml();
 197
 198     for (int i = 0; i < 7; ++i)
 199     {
 200         XmlElement* e = paintRoutines [i]->createXml();
 201         e->setAttribute ("buttonState", stateNames [i]);
 202         e->setAttribute ("enabled", paintStatesEnabled [i]);
 203
 204         doc->addChildElement (e);
 205     }
 206
 207     return doc;
 208 }
 209
 210 bool ButtonDocument::loadFromXml (const XmlElement& xml)
 211 {
 212     if (JucerDocument::loadFromXml (xml))
 213     {
 214         for (int i = 7; --i >= 0;)
 215             paintStatesEnabled [i] = false;
 216
 217         forEachXmlChildElementWithTagName (xml, e, PaintRoutine::xmlTagName)
 218         {
 219             const int stateIndex = stateNameToIndex (e->getStringAttribute ("buttonState"));
 220
 221             paintRoutines [stateIndex]->loadFromXml (*e);
 222             paintStatesEnabled [stateIndex] = e->getBoolAttribute ("enabled", stateIndex < normalOn);
 223         }
 224
 225         changed();
 226         getUndoManager().clearUndoHistory();
 227         return true;
 228     }
 229
 230     return false;
 231 }
 232
 233 void ButtonDocument::getOptionalMethods (StringArray& baseClasses,
 234                                          StringArray& returnValues,
 235                                          StringArray& methods,
 236                                          StringArray& initialContents) const
 237 {
 238     JucerDocument::getOptionalMethods (baseClasses, returnValues, methods, initialContents);
 239
 240     addMethod ("Button", "void", "clicked()", "", baseClasses, returnValues, methods, initialContents);
 241     addMethod ("Button", "void", "buttonStateChanged()", "", baseClasses, returnValues, methods, initialContents);
 242 }
 243
 244 //==============================================================================
 245 class ButtonStatePaintEnabledProperty   : public BooleanPropertyComponent,
 246                                           private ChangeListener
 247 {
 248 public:
 249     ButtonStatePaintEnabledProperty (const String& name, ButtonDocument& document_, const int stateMethod_)
 250         : BooleanPropertyComponent (name, "enabled", "disabled"),
 251           document (document_),
 252           stateMethod (stateMethod_)
 253     {
 254         document.addChangeListener (this);
 255     }
 256
 257     ~ButtonStatePaintEnabledProperty()
 258     {
 259         document.removeChangeListener (this);
 260     }
 261
 262     void setState (bool newState)
 263     {
 264         document.setStatePaintRoutineEnabled (stateMethod, newState);
 265     }
 266
 267     bool getState() const
 268     {
 269         return document.isStatePaintRoutineEnabled (stateMethod);
 270     }
 271
 272 private:
 273     void changeListenerCallback (ChangeBroadcaster*)
 274     {
 275         refresh();
 276     }
 277
 278     ButtonDocument& document;
 279     const int stateMethod;
 280 };
 281
 282 void ButtonDocument::addExtraClassProperties (PropertyPanel* panel)
 283 {
 284     Array <PropertyComponent*> props;
 285
 286     for (int i = 1; i < 7; ++i)
 287         props.add (new ButtonStatePaintEnabledProperty (stateNames[i], *this, i));
 288
 289     panel->addSection ("Button paint routines", props);
 290 }
 291
 292 //==============================================================================
 293 class ButtonTestComponent   : public Button
 294 {
 295 public:
 296     ButtonTestComponent (ButtonDocument* const document_, const bool alwaysFillBackground_)
 297         : Button (String::empty),
 298           document (document_),
 299           alwaysFillBackground (alwaysFillBackground_)
 300     {
 301         setClickingTogglesState (true);
 302     }
 303
 304     ~ButtonTestComponent()
 305     {
 306     }
 307
 308     void paintButton (Graphics& g, bool isMouseOverButton, bool isButtonDown)
 309     {
 310         if (document->paintStatesEnabled [background])
 311         {
 312             document->paintRoutines [background]->fillWithBackground (g, alwaysFillBackground);
 313             document->paintRoutines [background]->drawElements (g, Rectangle<int> (0, 0, getWidth(), getHeight()));
 314         }
 315
 316         const int stateIndex
 317             = getToggleState()
 318                 ? (isButtonDown ? document->chooseBestEnabledPaintRoutine (downOn)
 319                                 : (isMouseOverButton ? document->chooseBestEnabledPaintRoutine (overOn)
 320                                                      : document->chooseBestEnabledPaintRoutine (normalOn)))
 321                 : (isButtonDown ? document->chooseBestEnabledPaintRoutine (downOff)
 322                                 : (isMouseOverButton ? document->chooseBestEnabledPaintRoutine (overOff)
 323                                                      : normalOff));
 324
 325         document->paintRoutines [stateIndex]->fillWithBackground (g, ! document->paintStatesEnabled [background]);
 326         document->paintRoutines [stateIndex]->drawElements (g, Rectangle<int> (0, 0, getWidth(), getHeight()));
 327     }
 328
 329 private:
 330     ButtonDocument* const document;
 331     const bool alwaysFillBackground;
 332 };
 333
 334 Component* ButtonDocument::createTestComponent (const bool alwaysFillBackground)
 335 {
 336     return new ButtonTestComponent (this, alwaysFillBackground);
 337 }
 338
 339 //==============================================================================
 340 void ButtonDocument::fillInGeneratedCode (GeneratedCode& code) const
 341 {
 342     JucerDocument::fillInGeneratedCode (code);
 343
 344     code.parentClassInitialiser = "Button (" + quotedString (code.componentName) + ")";
 345     code.removeCallback ("void", "paint (Graphics& g)");
 346 }
 347
 348 void ButtonDocument::fillInPaintCode (GeneratedCode& code) const
 349 {
 350     jassert (paintStatesEnabled [normalOff]);
 351     String paintCode [7];
 352
 353     for (int i = 0; i < 7; ++i)
 354         if (paintStatesEnabled [i])
 355             paintRoutines[i]->fillInGeneratedCode (code, paintCode [i]);
 356
 357     String& s = code.getCallbackCode ("public Button",
 358                                       "void",
 359                                       "paintButton (Graphics& g, bool isMouseOverButton, bool isButtonDown)",
 360                                       false);
 361
 362     int numPaintRoutines = getNumPaintRoutines();
 363
 364     if (paintStatesEnabled [background])
 365     {
 366         s << paintCode [background] << "\n";
 367         --numPaintRoutines;
 368     }
 369
 370     if (numPaintRoutines == 1)
 371     {
 372         s << paintCode [normalOff];
 373     }
 374     else if (numPaintRoutines == downOff && (paintStatesEnabled [overOff] || paintStatesEnabled [downOff] || paintStatesEnabled [normalOn]))
 375     {
 376         if (paintStatesEnabled [normalOn])
 377         {
 378             s << "if (getToggleState())\n{\n    "
 379               << indentCode (paintCode [normalOn], 4).trimEnd();
 380         }
 381         else if (paintStatesEnabled [overOff])
 382         {
 383             s << "if (isButtonDown || isMouseOverButton)\n{\n    "
 384               << indentCode (paintCode [overOff], 4).trimEnd();
 385         }
 386         else
 387         {
 388             s << "if (isButtonDown)\n{\n    "
 389               << indentCode (paintCode [downOff], 4).trimEnd();
 390         }
 391
 392         s << "\n}\nelse\n{\n    "
 393           <<  indentCode (paintCode [normalOff], 4).trimEnd()
 394           << "\n}\n";
 395     }
 396     else if (numPaintRoutines == normalOn && paintStatesEnabled [overOff] && paintStatesEnabled [downOff])
 397     {
 398         s << "if (isButtonDown)\n{\n    "
 399           << indentCode (paintCode [downOff], 4).trimEnd()
 400           << "\n}\nelse if (isMouseOverButton)\n{\n    "
 401           << indentCode (paintCode [overOff], 4).trimEnd()
 402           << "\n}\nelse\n{\n    "
 403           << indentCode (paintCode [normalOff], 4).trimEnd()
 404           << "\n}\n";
 405     }
 406     else
 407     {
 408         if (paintStatesEnabled [normalOn] || paintStatesEnabled [overOn] || paintStatesEnabled [downOn])
 409         {
 410             s << "switch (getToggleState() ? (isButtonDown ? "
 411               << chooseBestEnabledPaintRoutine (downOn) << " : (isMouseOverButton ? "
 412               << chooseBestEnabledPaintRoutine (overOn) << " : "
 413               << chooseBestEnabledPaintRoutine (normalOn) << "))\n                         : (isButtonDown ? "
 414               << chooseBestEnabledPaintRoutine (downOff) << " : (isMouseOverButton ? "
 415               << chooseBestEnabledPaintRoutine (overOff) << " : 0)))\n{\n";
 416         }
 417         else
 418         {
 419             s << "switch (isButtonDown ? " << chooseBestEnabledPaintRoutine (downOff)
 420               << " : (isMouseOverButton ? " << chooseBestEnabledPaintRoutine (overOff)
 421               << " : 0))\n{\n";
 422         }
 423
 424         for (int i = 0; i < 6; ++i)
 425         {
 426             if (paintStatesEnabled [i])
 427             {
 428                 s << "case " << i << ":\n    {\n        "
 429                   << indentCode (paintCode [i], 8).trimEnd()
 430                   << "\n        break;\n    }\n\n";
 431             }
 432         }
 433
 434         s << "default:\n    break;\n}\n";
 435     }
 436 }